import type { $InputVerify } from '@/mxp-ui/mxp-tool/types/interface';
/** ********************整数**********************整数 */
/** ********************整数**********************整数 */
/** ********************整数**********************整数 */
// 正整数(不含0)
export const add_int_numb_RegEx = /^[1-9]\d*$/;

// 负整数(不含0)
export const minus_int_numb_RegEx = /^-[1-9]\d*$/;

// 整数 ( 不含0(正负都可以)
export const all_int_numb_RegEx = /^-?[1-9]\d*$/;

// 正整数(含0)
export const add_int_or_zero_numb_RegEx = /^[1-9]\d*$|^0$/;

// 负整数 (含0)
export const minus_int_or_zero_numb_RegEx = /^-[1-9]\d*$|^0$/;

// 正负整数 (含0)
export const all_int_or_zero_numb_RegEx = /^-?[1-9]\d*$|^0$/;

/** ********************浮点数**********************浮点数 */
/** ********************浮点数**********************浮点数 */
/** ********************浮点数**********************浮点数 */

// 正浮点数 (不含0)
export const add_float_numb_RegEx = /(^[1-9]\d*|^0)\.\d+$/;

// 负浮点数(不含0)
export const minus_float_numb_RegEx = /(^-[1-9]\d*|^-0)\.\d+$/;

// 正浮点数 (含0)
export const add_float_ro_zero_numb_RegEx = /(^[1-9]\d*|^0)\.\d+$|^0$/;

// 负浮点数(含0)
export const minus_float_ro_zero_numb_RegEx = /(^-[1-9]\d*|^-0)\.\d+$|^0$/;

// 浮点数(包含正负浮点数不含0)
export const all_float_numb_RegEx = /(^-?[1-9]\d*|^-?0)\.\d+$/;

// 浮点数(包含正负浮点数和0)
export const all_float_or_zero_numb_RegEx = /(^-?[1-9]\d*|^-?0)\.\d+$|^0$/;

// 所有合法数字 (整数，小数，正数，负数，0) 【不推荐用正则验证直接用isNaN(numb)并判断大于小于就可以了】
export const all_numb = /(^-?[1-9]\d*|^-?0)(\.\d+)?$/;

/** ********************数字输入时正则**********************数字输入时正则 */
/** ********************数字输入时正则**********************数字输入时正则 */
/** ********************数字输入时正则**********************数字输入时正则 */

// 正整数 (不含0) 主要用于输入时验证
export const add_int_numb_input_RegEx = /^[1-9]\d*/;

// 负整数(不含0) 主要用于输入时验证
export const minus_int_numb_input_RegEx = /^-?[1-9]\d*/;

// 正负整数(不含0) 主要用于输入时验证
export const all_int_numb_input_RegEx = /^-?[1-9]\d*/;

// 正整数 (含0) 主要用于输入时验证
export const add_int_or_zero_numb_input_RegEx = /^[1-9]\d*$|^0/;

// 负整数 (含0) 主要用于输入时验证
export const minus_int_or_zero_numb_input_RegEx = /^-?[1-9]\d*$|^0/;

// 正负整数(含0) 主要用于输入时验证
export const all_int_or_zero_numb_input_RegEx = /^-?\d*|^0/;

// 正浮点数 主要用于输入时验证
export const add_float_numb_input_RegEx = /^\d+\.?\d*/;

// 负浮点数 主要用于输入时验证
export const minus_float_numb_input_RegEx = /^-?\d*\.?\d*/;

// 正负浮点数  主要用于输入时验证 【这里就可以验证合法的数字输入了包含 0.   -   -0. 】
export const all_float_numb_input_RegEx = /^-?\d*\.?\d*/;

/** *******************数字验证****************数字验证 */
/** *******************数字验证****************数字验证 */
/** *******************数字验证****************数字验证 */
/**
 * 正整数 (不含0)
 */
export function verifyAddIntNumb(str: string): boolean {
  return Boolean(add_int_numb_RegEx.test(str));
}

/**
 * 负整数(不含0)
 */
export function verifyMinusIntNumb(str: string): boolean {
  return Boolean(minus_int_numb_RegEx.test(str));
}

/**
 * 正负整数(不含0)
 */
export function verifyAllIntNumb(str: string): boolean {
  return Boolean(all_int_numb_RegEx.test(str));
}

/**
 * 正整数 (含0)
 */
export function verifyAddIntRoZeroNumb(str: string): boolean {
  return Boolean(add_int_or_zero_numb_RegEx.test(str));
}

/**
 * 负整数 (含0)
 */
export function verifyMinusIntRoZeroNumb(str: string): boolean {
  return Boolean(minus_int_or_zero_numb_RegEx.test(str));
}

/**
 * 正 负 整数(含0)
 */
export function verifyAllIntRoZeroNumb(str: string): boolean {
  return Boolean(all_int_or_zero_numb_RegEx.test(str));
}

/**
 * 正浮点数
 */
export function verifyAddFloatNumb(str: string): boolean {
  return Boolean(add_float_numb_RegEx.test(str));
}

/**
 * 负浮点数
 */
export function verifyMinusFloatNumb(str: string): boolean {
  return Boolean(minus_float_numb_RegEx.test(str));
}

/**
 * 正负浮点数
 */
export function verifyAllsFloatNumb(str: string): boolean {
  return Boolean(all_float_numb_RegEx.test(str));
}

/** *******************输入时验证****************输入时验证 */
/** *******************输入时验证****************输入时验证 */
/** *******************输入时验证****************输入时验证 */

/**
 * 正整数 (不含0) 主要用于输入时验证
 */
export function verifyAddIntNumbInput(str: number | string): string {
  const numbArr: RegExpMatchArray | null = String(str).match(add_int_numb_input_RegEx);
  let numb: string = Array.isArray(numbArr) ? numbArr[0] : '';
  numb = numb.replace(/^0+/g, '0');
  return numb;
}

/**
 * 负整数(不含0) 主要用于输入时验证
 */
export function verifyMinusIntNumbInput(str: number | string): string {
  const numbArr = String(str).match(minus_int_numb_input_RegEx);
  let numb: string = Array.isArray(numbArr) ? numbArr[0] : '';
  numb = numb.replace(/^0+/g, '0');
  numb = numb !== '' && numb !== '0' && numb.startsWith('-') ? numb : `-${numb}`;
  return numb;
}

/**
 * 正负整数(不含0) 主要用于输入时验证
 */
export function verifyAllIntNumbInput(str: number | string): string {
  const numbArr = String(str).match(all_int_numb_input_RegEx);
  let numb = Array.isArray(numbArr) ? numbArr[0] : '';
  numb = numb.replace(/^0+/g, '0');
  return numb;
}

/**
 * 正整数 (含0) 主要用于输入时验证
 */
export function verifyAddIntRoZeroNumbInput(str: number | string): string {
  const numbArr = String(str).match(add_int_or_zero_numb_input_RegEx);
  let numb = Array.isArray(numbArr) ? numbArr[0] : '';
  numb = numb.replace(/^0+/g, '0');
  return numb;
}

/**
 * 负整数 (含0) 主要用于输入时验证
 */
export function verifyMinusIntRoZeroNumbInput(str: number | string): string {
  const numbArr = String(str).match(minus_int_or_zero_numb_input_RegEx);
  let numb = Array.isArray(numbArr) ? numbArr[0] : '';
  numb = numb.replace(/^0+/g, '0');
  numb = numb.replace(/^-0+/g, '0');
  numb = numb !== '' && numb !== '0' && numb.startsWith('-') ? numb : `-${numb}`;
  return numb;
}

/**
 * 正 负 整数(含0) 主要用于输入时验证
 */
export function verifyAllIntRoZeroNumbInput(str: number | string): string {
  const numbArr = String(str).match(all_int_or_zero_numb_input_RegEx);
  let numb = Array.isArray(numbArr) ? numbArr[0] : '';
  numb = numb.replace(/^0+/g, '0');
  numb = numb.replace(/^-0+/g, '-');
  numb = !isNaN(Number(numb)) ? String(Number(numb)) : numb;
  return numb;
}

/**
 * 正浮点数 主要用于输入时验证
 */
export function verifyAddFloatNumbInput(str: number | string): string {
  let numb = str;
  if (str === '.') {
    numb = '0.';
  } else {
    const numbArr = String(numb).match(add_float_numb_input_RegEx);
    numb = Array.isArray(numbArr) ? numbArr[0] : '';
    numb = numb.replace(/^0+/g, '0');
    numb = numb.replace(/^0+\./g, '0.');
    numb = numb.match(/^0+[1-9]+/) ? numb.replace(/^0+/g, '') : numb;
  }
  return numb;
}

/**
 * 负浮点数 主要用于输入时验证
 */
export function verifyMinusFloatNumbInput(str: number | string): string {
  let numb = str;
  if (str === '.') {
    numb = '-0.';
  } else {
    const numbArr = String(str).match(minus_float_numb_input_RegEx);
    numb = Array.isArray(numbArr) ? numbArr[0] : '';
    numb = numb.replace(/^0+/g, '0');
    numb = numb.replace(/^-0+/g, '-0');
    numb = numb.replace(/^0+\./g, '0.');
    numb = numb.replace(/^-\./g, '-0.');
    numb = numb.match(/^0+[1-9]+/) ? numb.replace(/^0+/g, '') : numb;
    numb = numb !== '' && numb !== '0' && numb.startsWith('-') ? numb : `-${numb}`;
  }
  return numb;
}

/**
 * 正负浮点数   主要用于输入时验证
 */
export function verifyAllFloatNumbInput(str: number | string): string {
  let numb = str;
  if (str === '.') {
    numb = '0.';
  } else {
    const numbArr = String(str).match(all_float_numb_input_RegEx);
    numb = Array.isArray(numbArr) ? numbArr[0] : '';
    numb = numb.replace(/^0+/g, '0');
    numb = numb.replace(/^-0+/g, '-0');
    numb = numb.replace(/^0+\./g, '0.');
    numb = numb.replace(/^-\./g, '-0.');
    numb = numb.match(/^0+[1-9]+/) ? numb.replace(/^0+/g, '') : numb;
  }
  return numb;
}

/**
 * 验证数字
 * @param verify - 验证类型
 * @param numb - 需要验证的数字
 * @param oldNumb - 修改之前的
 */
export function verifyNumbInput(verify: $InputVerify | undefined, numb: number | string, oldNumb: number | string) {
  let newNumb = isNaN(Number(numb)) && numb !== '.' && numb !== '-' ? oldNumb : numb;
  if (verify === 'add_int') {
    // 正整数 (不含0) 主要用于输入时验证
    newNumb = verifyAddIntNumbInput(newNumb);
  } else if (verify === 'minus_int') {
    // 负整数(不含0) 主要用于输入时验证
    newNumb = verifyMinusIntNumbInput(newNumb);
  } else if (verify === 'all_int') {
    // 正负整数(不含0) 主要用于输入时验证
    newNumb = verifyAllIntNumbInput(newNumb);
  } else if (verify === 'add_int_or_zero') {
    // 正整数 (含0) 主要用于输入时验证
    newNumb = verifyAddIntRoZeroNumbInput(newNumb);
  } else if (verify === 'minus_int_or_zero') {
    // 负整数 (含0) 主要用于输入时验证
    newNumb = verifyMinusIntRoZeroNumbInput(newNumb);
  } else if (verify === 'all_int_or_zero') {
    // 正负整数(含0) 主要用于输入时验证
    newNumb = verifyAllIntRoZeroNumbInput(newNumb);
  } else if (verify === 'add_float') {
    // 正浮点数  主要用于输入时验证
    newNumb = verifyAddFloatNumbInput(newNumb);
  } else if (verify === 'minus_float') {
    // 负浮点数 主要用于输入时验证
    newNumb = verifyMinusFloatNumbInput(newNumb);
  } else if (verify === 'all_float') {
    // 正负浮点数   主要用于输入时验证
    newNumb = verifyAllFloatNumbInput(newNumb);
  }
  if (newNumb !== '') {
    return newNumb;
  } else {
    return !isNaN(Number(oldNumb)) ? oldNumb : '';
  }
}
